
import LoginStatus from "./loginStatus"
import { isEmptyObject, isEmptyString } from "./utils"

// 用户 信息的本地缓存键名
const KEY_USER_INFO = "KEY_USER_INFO"

// 设备标识 信息的本地缓存键名
const KEY_DEVICE_ID_INFO = "KEY_DEVICE_ID_INFO"

// aduid 信息的本地缓存键名
const KEY_ADUID_INFO = "KEY_ADUID_INFO"

// 首页第1个币 信息的本地缓存键名
const KEY_COIN_INFO = "KEY_COIN_INFO"

// 管理钱包cointype 信息的本地缓存键名
const KEY_MANAGE_WALLET_COINTYPE = "KEY_MANAGE_WALLET_COINTYPE"

// 当前提币 信息的本地缓存键名
const KEY_TRANSFER_INFO = "KEY_TRANSFER_INFO"

// 提币结果 信息的本地缓存键名
const KEY_TRANSFER_RESULT_INFO = "KEY_TRANSFER_RESULT_INFO"

// asset详情 信息的本地缓存键名
const KEY_ASSET_DETAIL_INFO = "KEY_ASSET_DETAIL_INFO"

// asset结果 信息的本地缓存键名
const KEY_ASSET_RESULT_INFO = "KEY_ASSET_RESULT_INFO"

// 提现结果 信息的本地缓存键名
const KEY_WITHDRAW_RESULT_INFO = "KEY_WITHDRAW_RESULT_INFO"

/**
 * 从本地缓存中获取 用户 信息
 */
export const getUserInfo = () => {
    console.log("读用户缓存：")
    if (!isEmptyObject(LoginStatus.loginInfo)) {
        console.log(LoginStatus.loginInfo)
        return LoginStatus.loginInfo
    }
    const userInfo = JSON.parse(localStorage.getItem(KEY_USER_INFO) || "{}")
    LoginStatus.loginInfo = userInfo
    console.log(userInfo)
    return userInfo
}

/**
 * 将 用户 信息存入缓存
 * @param {Object} userInfo 从后端获取到的 用户 信息
 */
export const setUserInfo = userInfo => {
    //保存静态数据
    LoginStatus.loginInfo = userInfo
    try {
        //再保存本地
        localStorage.setItem(KEY_USER_INFO, JSON.stringify(userInfo || {}))
    } catch (e) {
    }
}

/**
 * 删除本地缓存中的 用户 信息
 */
export const removeUserInfo = () => {
    LoginStatus.loginInfo = null
    localStorage.removeItem(KEY_USER_INFO)
}


/**
 * 从本地缓存中获取 当前提币 信息
 */
export const getTransferInfo = () => {
    console.log("读 当前提币 缓存：")
    if (!isEmptyObject(LoginStatus.transferInfo)) {
        console.log(LoginStatus.transferInfo);
        return LoginStatus.transferInfo;
    }
    const transferInfo = JSON.parse(localStorage.getItem(KEY_TRANSFER_INFO) || "{}");
    LoginStatus.transferInfo = transferInfo;
    console.log(transferInfo);
    return transferInfo;
}


/**
 * 将 当前提币 信息存入缓存
 * @param {Object} transferResultInfo 从后端获取到的 首页第1个币 信息
 */
export const setTransferInfo = transferInfo => {
    //保存静态数据
    LoginStatus.transferInfo = transferInfo
    try {
        //再保存本地
        localStorage.setItem(KEY_TRANSFER_INFO, JSON.stringify(transferInfo || {}))
    } catch (e) {
    }
}


/**
 * 从本地缓存中获取 提币结果 信息
 */
export const getTransferResultInfo = () => {
    console.log("读 提币结果 缓存：")
    if (!isEmptyObject(LoginStatus.transferResultInfo)) {
        console.log(LoginStatus.transferResultInfo);
        return LoginStatus.transferResultInfo;
    }
    const transferResultInfo = JSON.parse(localStorage.getItem(KEY_TRANSFER_RESULT_INFO) || "{}");
    LoginStatus.transferResultInfo = transferResultInfo;
    console.log(transferResultInfo);
    return transferResultInfo;
}


/**
 * 将 提币结果 信息存入缓存
 * @param {Object} transferResultInfo 从后端获取到的 首页第1个币 信息
 */
export const setTransferResultInfo = transferResultInfo => {
    //保存静态数据
    LoginStatus.transferResultInfo = transferResultInfo
    try {
        //再保存本地
        localStorage.setItem(KEY_TRANSFER_RESULT_INFO, JSON.stringify(transferResultInfo || {}))
    } catch (e) {
    }
}


/**
 * 从本地缓存中获取 asset detail 信息
 */
export const getAssetDetailInfo = () => {
    console.log("读 asset detail 缓存：")
    if (!isEmptyObject(LoginStatus.assetDetailInfo)) {
        console.log(LoginStatus.assetDetailInfo);
        return LoginStatus.assetDetailInfo;
    }
    const assetDetailInfo = JSON.parse(localStorage.getItem(KEY_ASSET_DETAIL_INFO) || "{}");
    LoginStatus.assetDetailInfo = assetDetailInfo;
    console.log(assetDetailInfo);
    return assetDetailInfo;
}


/**
 * 将 asset detail 信息存入缓存
 * @param {Object} assetDetailInfo 从后端获取到的 首页第1个币 信息
 */
export const setAssetDetailInfo = assetDetailInfo => {
    //保存静态数据
    LoginStatus.assetDetailInfo = assetDetailInfo
    try {
        //再保存本地
        localStorage.setItem(KEY_ASSET_DETAIL_INFO, JSON.stringify(assetDetailInfo || {}))
    } catch (e) {
    }
}


/**
 * 从本地缓存中获取 asset detail 信息
 */
export const getAssetResultInfo = () => {
    console.log("读 asset result 缓存：")
    if (!isEmptyObject(LoginStatus.assetResultInfo)) {
        console.log(LoginStatus.assetResultInfo);
        return LoginStatus.assetResultInfo;
    }
    const assetResultInfo = JSON.parse(localStorage.getItem(KEY_ASSET_RESULT_INFO) || "{}");
    LoginStatus.assetResultInfo = assetResultInfo;
    console.log(assetResultInfo);
    return assetResultInfo;
}


/**
 * 将 asset detail 信息存入缓存
 * @param {Object} assetResultInfo 从后端获取到的 首页第1个币 信息
 */
export const setAssetResultInfo = assetResultInfo => {
    //保存静态数据
    LoginStatus.assetResultInfo = assetResultInfo
    try {
        //再保存本地
        localStorage.setItem(KEY_ASSET_RESULT_INFO, JSON.stringify(assetResultInfo || {}))
    } catch (e) {
    }
}



/**
 * 从本地缓存中获取 提现结果 信息
 */
export const getWithdrawResultInfo = () => {
    console.log("读 提现结果 缓存：")
    if (!isEmptyObject(LoginStatus.withdrawResultInfo)) {
        console.log(LoginStatus.withdrawResultInfo);
        return LoginStatus.withdrawResultInfo;
    }
    const withdrawResultInfo = JSON.parse(localStorage.getItem(KEY_WITHDRAW_RESULT_INFO) || "{}");
    LoginStatus.withdrawResultInfo = withdrawResultInfo;
    console.log(withdrawResultInfo);
    return withdrawResultInfo;
}


/**
 * 将 提现结果 信息存入缓存
 * @param {Object} withdrawResultInfo 从后端获取到的 首页第1个币 信息
 */
export const setWithdrawResultInfo = withdrawResultInfo => {
    //保存静态数据
    LoginStatus.withdrawResultInfo = withdrawResultInfo
    try {
        //再保存本地
        localStorage.setItem(KEY_WITHDRAW_RESULT_INFO, JSON.stringify(withdrawResultInfo || {}))
    } catch (e) {
    }
}


/**
 * 将 管理钱包cointype 信息存入缓存
 * @param {String} coinType 从后端获取到的 首页第1个币 信息
 */
export const setManageWalletCoinType = coinType => {
    //保存静态数据
    LoginStatus.manageWalletCoinType = coinType
    try {
        //再保存本地
        localStorage.setItem(KEY_MANAGE_WALLET_COINTYPE, coinType || "")
    } catch (e) {
    }
}

/**
 * 从本地缓存中获取 管理钱包cointype 信息
 */
export const getManageWalletCoinType = () => {
    console.log("读 首页第1个币 缓存：")
    if (LoginStatus.manageWalletCoinType && (LoginStatus.manageWalletCoinType.length > 0)) {
        console.log(LoginStatus.manageWalletCoinType);
        return LoginStatus.manageWalletCoinType;
    }
    const coinType = localStorage.getItem(KEY_MANAGE_WALLET_COINTYPE) || "";
    LoginStatus.manageWalletCoinType = coinType;
    console.log(coinType);
    return coinType;
}



/**
 * 从本地缓存中获取 首页第1个币 信息
 */
export const getCoinInfo = () => {
    console.log("读 首页第1个币 缓存：")
    if (!isEmptyObject(LoginStatus.coinInfo)) {
        console.log(LoginStatus.coinInfo);
        return LoginStatus.coinInfo;
    }
    const coinInfo = JSON.parse(localStorage.getItem(KEY_COIN_INFO) || "{}");
    LoginStatus.coinInfo = coinInfo;
    console.log(coinInfo);
    return coinInfo;
}


/**
 * 将 首页第1个币 信息存入缓存
 * @param {Object} coinInfo 从后端获取到的 首页第1个币 信息
 */
export const setCoinInfo = coinInfo => {
    //保存静态数据
    LoginStatus.coinInfo = coinInfo
    try {
        //再保存本地
        localStorage.setItem(KEY_COIN_INFO, JSON.stringify(coinInfo || {}))
    } catch (e) {
    }
}



/**
 * 判断本地缓存中是否存在 用户 信息
 */
export const isLogin = () => {
    return !isEmptyString(getUserInfo().token)
}


/**
 * 从本地缓存中获取 设备标识 信息
 * 
 * @returns {String} device id
 */
export const getDeviceIDInfo = () => {
    const deviceIDInfo = localStorage.getItem(KEY_DEVICE_ID_INFO) || ""
    console.log("读设备ID缓存: " + deviceIDInfo)
    return deviceIDInfo
}

/**
 * 将 设备标识 信息存入缓存
 * @param {String} device id 
 */
export const setDeviceIDInfo = deviceID => {
    try {
        //再保存本地
        localStorage.setItem(KEY_DEVICE_ID_INFO, (deviceID || ""))
    } catch (e) {
    }
}

/**
 * 删除本地缓存中的 device id 信息
 */
export const removeDeviceIDInfo = () => {
    localStorage.removeItem(KEY_DEVICE_ID_INFO)
}


/**
 * 从本地缓存中获取 aduid 信息
 * 
 * @returns {String} aduid
 */
export const getAduidInfo = () => {
    const aduidInfo = localStorage.getItem(KEY_ADUID_INFO) || ""
    console.log("读aduid缓存: " + aduidInfo)
    return aduidInfo
}

/**
 * 将 aduid 信息存入缓存
 * @param {String} aduid  
 */
export const setAduidInfo = aduid => {
    try {
        localStorage.setItem(KEY_ADUID_INFO, (aduid || ""))
    } catch (e) {
    }
}

/**
 * 删除本地缓存中的 aduid 信息
 */
export const removeAduidInfo = () => {
    localStorage.removeItem(KEY_ADUID_INFO)
}
